package com.bitoon.basketdudes.web;

import com.bitoon.basketdudes.javamail.Mail;
import com.bitoon.basketdudes.web.datos.DatosCalendario;
import com.bitoon.basketdudes.web.datos.DatosCalendarioTorneo;
import com.bitoon.basketdudes.web.datos.DatosEstadisticaTorneo;
import com.bitoon.basketdudes.web.datos.InfoCabeceraXHR;
import com.bitoon.basketdudes.web.datos.MensajeUsuario;
import com.bitoon.basketdudes.web.jpa.*;
import com.bitoon.basketdudes.web.xhr.ListaTorneosUsuario;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.*;
import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.Query;
import org.apache.log4j.Logger;
import org.apache.struts2.ServletActionContext;

public class TorneoUsuario extends BaseListadoResultados {

    private Logger log = Logger.getLogger(TorneoUsuario.class);

    public static final String TORNEO_INICIADO = "torneo_iniciado";
    public static final String TORNEO_INICIO = "torneo_inicio";
    public static final String TORNEO_CALENDARIO = "torneo_calendario";
    public static final String TORNEO_RESULTADOS = "torneo_resultados";
    public static final String TORNEO_ESTADISTICAS = "torneo_estadisticas";
    public static final String TORNEO_EQUIPOS = "torneo_equipos";
    public static final String TORNEO_CLASIFICACION = "torneo_clasificacion";
    public static final String TORNEO_MENSAJES = "torneo_mensajes";

    public static final String MAX_TORNEOS = "max_torneos";
    private static int MAX_TORNEOS_ADMINISTRADOR = 1;
    private static int MAX_INVITACIONES_ANTISPAM = 16;

    public static final int ID_TROFEO_POSICION_1 = 51;
    public static final int ID_TROFEO_POSICION_2 = 52;

    private String nombre_torneo;
    private String tipo_torneo;
    private String contrasenya_torneo;
    private short numero_participantes;
    private short numero_entre;
    private short numero_y;
    private int frecuencia; // frecuencia de partidos, en días
    private int equipo_inscrito;
    private String invitaciones;
    private String descripcion;

    // Para la ficha del torneo
    private Temporada temporada;
    private Torneo torneo;
    private List<Participe> listaAdmitidos;
    private List<Participe> clasificacion;
    private List<MensajeUsuario> listaMensajesTorneo;
    private Jornada jornadaEnCurso;
    private boolean temporadaIniciada = true;
    private boolean temporadaFinalizada = false;

    // Para recibir la jornada en "resultados"
    private int jornada;

    private String urlRedirect;

    private String urlTorneo; // Para la página de la ficha de torneo

    // Para las llamadas XHR de paginacion de equipos pendientes
    private List<Participe> datos;
    private InfoCabeceraXHR cabecera;
    private int pagina = 1;
    private int cuantos;

    public static String patternNombreTorneo = "[0-9a-zA-ZñÑ _.]*";

    // Cadena para los checkbox de "elegir_equipo" y "administrar"
    private String accion = "";
    private String[] elegir_equipo;
    private String fecha;
    private String fecha_aplazamiento;
    private String mensaje_administrador;
    private int idPartido;
    private int idTorneo;
    private int resultadoAdministracion; // Para el xhr

    // Para iniciar la liga
    private String fecha_inicio = "";

    // Para calendario
    private List<DatosCalendarioTorneo> partidosCalendario;
    private List<DatosCalendarioTorneo> partidosCalendarioJornada;
    private List<DatosCalendarioTorneo> partidosPendientes;
    private List<DatosCalendarioTorneo> partidosPendientesAdministrador;
    //private List<DatosCalendarioTorneo> partidosCalendarioCarrusel;
    private int numJornadasCarrusel;

    // El calendario del scroll
    private List<DatosCalendario> calendario;

    // Para la recepción de mensajes
    private String mensajeTorneo = null;

    // Estadísticas
    private List<DatosEstadisticaTorneo> estValoracionTorneo;
    private List<DatosEstadisticaTorneo> estAnotacionTorneo;
    private List<DatosEstadisticaTorneo> estRebotesTorneo;
    private List<DatosEstadisticaTorneo> estAsistenciasTorneo;
    private List<DatosEstadisticaTorneo> estTaponesTorneo;
    private List<DatosEstadisticaTorneo> estRecuperacionesTorneo;

    

    @Override
    public String execute() {
        String retorno = SUCCESS;

        return retorno;
    }

    public String crear() {
        log.debug("crearrrrrrrr ");
        String retorno = SUCCESS;
        
        if (getUsuarioLogado()!=null) {

            // Ver que no tenga el máximo de torneos creados

            List<Temporada> temporadasAdministrador = null;

            EntityManager em = null;
            try {
                // Comprobaciones previas
                boolean cumpleComprobaciones = true;

                em = emfBasket.createEntityManager(); // checked

                if (getUsuarioLogado()!=null) {
                    Query q = em.createNamedQuery("Temporada.findActivasByUsuarioId");
                    q.setParameter("idUsuario", getUsuarioLogado().getId());
                    temporadasAdministrador = (List<Temporada>)q.getResultList();

                    if (temporadasAdministrador==null || temporadasAdministrador.size() >= MAX_TORNEOS_ADMINISTRADOR) {
                        setMensajeAlerta(getText("alertas.torneos_de_usuario.crear.maximo_ligas_administrador"));
                        retorno = MAX_TORNEOS;
                        cumpleComprobaciones = false;
                    }
                }

                Pattern pt = Pattern.compile(patternNombreTorneo);
                if (nombre_torneo!=null) {
                    if (!pt.matches(patternNombreTorneo,nombre_torneo)) {
                        cumpleComprobaciones = false;
                    } else {
                        if (nombre_torneo.length()<=0 || nombre_torneo.length()>34) {
                            cumpleComprobaciones=false;
                        }
                    }
                } else {
                    cumpleComprobaciones = false; // nombre no puede ser null
                }
                if (numero_entre > numero_y) {
                    short aux = numero_y;
                    numero_y = numero_entre;
                    numero_entre = aux;
                }
                if (numero_participantes<4 || numero_participantes>8) {
                    cumpleComprobaciones=false;
                }

                if (cumpleComprobaciones) {

                    //log.debug("temporadasAdministrador: " + temporadasAdministrador);

                    if (temporadasAdministrador==null || temporadasAdministrador.size() >= MAX_TORNEOS_ADMINISTRADOR) {
                        setMensajeAlerta(getText("alertas.torneos_de_usuario.crear.maximo_ligas_administrador"));
                        retorno = MAX_TORNEOS;
                    } else {
                        if (nombre_torneo != null) {

                            Torneo torneo = new Torneo();
                            Temporada temporada = new Temporada();

                            torneo.setNombre(nombre_torneo);
                            UsuarioParcial usuario = em.find(UsuarioParcial.class, getIdUsuarioLogado());
                            //torneo.setUsuarioId(getIdUsuarioLogado());
                            torneo.setUsuario(usuario);
                            torneo.setNombreUrl(getNombreUrl(nombre_torneo));
                            torneo.setDescripcion(getDescripcion());

                            temporada.setEdicion((short)1); // Primera temporada
                            temporada.setMaxEquipos(numero_participantes);
                            temporada.setNivelIni(numero_entre);
                            temporada.setNivelFin(numero_y);
                            temporada.setFrecuencia((short)frecuencia);
                            temporada.setTiempoCuarto((short)2);
                            temporada.setCartas((short)1);
                            temporada.setTalentos((short)1);
                            temporada.setJornadas((short)(numero_participantes*2-2));

                            // Poner la fecha de inicio como actual para borrar las temporadas que lleven mucho tiempo sin inicarse

                            temporada.setFInicio(new Date());

                            // Faltaría equipo inscrito e invitaciones

                            log.debug("invitaciones: " + invitaciones);
                            mandarInvitaciones(false);

                            em.getTransaction().begin();
                            em.persist(torneo);

                            temporada.setTorneo(torneo);
                            temporada.setEstado((short)1); // Período inscripción
                            temporada.setTipo((short)1); // Tipo 1 = liga


                            //log.debug("Tipo torneo en creacion: " + tipo_torneo);

                            if (tipo_torneo.equals("privado")) {
                                temporada.setPrivada((short)1);
                                temporada.setPassword(contrasenya_torneo);
                            } else {
                                temporada.setPrivada((short)0);
                            }

                            //temporada.setTorneoId(torneo.getId());
                            em.persist(temporada);

                            // Asignar temporada_trofeo

                            TemporadaTrofeo temporadaTrofeo1 = new TemporadaTrofeo(temporada.getId(),ID_TROFEO_POSICION_1,(short)1);
                            TemporadaTrofeo temporadaTrofeo2 = new TemporadaTrofeo(temporada.getId(),ID_TROFEO_POSICION_2,(short)2);
                            em.persist(temporadaTrofeo1);
                            em.persist(temporadaTrofeo2);

                            em.getTransaction().commit();

                            // Equipo inscrito
                            if (equipo_inscrito > 0) {
                                // Comprobar que el equipo es del pájaro en cuestión
                                Equipo e = em.find(Equipo.class, equipo_inscrito);
                                if (e.getUsuario().getId()==getIdUsuarioLogado()) {
                                    // El usuario logado-creador es el dueño de su equipo
                                    int ret = ListaTorneosUsuario.apuntarse(temporada,
                                            e, contrasenya_torneo, log, em);
                                }
                            }

                            setUrlRedirect(torneo.getNombreUrl());
                            retorno = REDIRECT;
                        }
                    }
                }
            } catch (Exception e) {
                log.error("[execute]: ", e);
                setMensajeAlerta(getText("alertas.torneos_de_usuario.crear.error"));
                retorno = ERROR;
                if (em!=null && em.getTransaction().isActive()) { em.getTransaction().rollback(); }
            } finally {
                try { if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }; } catch (Exception e) { }
                try { em.close(); } catch (Exception e) { }
            }
        } else {
            retorno = NO_LOGADO;
        }

        return retorno;
    }


    public String invitar() {
        obtenerTorneo();
        mandarInvitaciones(true);
        return SUCCESS;
    }

    protected void mandarInvitaciones(boolean mostrarError) {
        if (invitaciones!=null) {
            procesarInvitaciones(mostrarError);
        }
    }
    
    protected void procesarInvitaciones(boolean mostrarError) {

        String[] arrayInvitaciones = invitaciones.split(",");
        // En Taiwan no se mandan emails de invitacion, sólo mensajería interna
        // Set<String> mailsEnviados = new HashSet<String>();
        Set<String> nicksEnviados = new HashSet<String>();
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked

            if (mostrarError) {
                setMensajeAlerta(getText("alertas.torneos_de_usuario.administrar.invitaciones_enviadas_error"));
            }
            
            int enviadas = 0;
            for(String invitado:arrayInvitaciones) {

                // Evitar mandar el mismo mail 2 veces

                boolean esUsuario = false;
                Usuario u = null;
                String emailTo = "";
                String nickTo = "";
                if (!invitado.contains("@")) {
                    // Presunto nick

                    Query qu = em.createNamedQuery("Usuario.findByNick");
                    qu.setParameter("nick", invitado.trim().toLowerCase());
                    log.debug("Buscando " + invitado);

                    List<Usuario> lu = (List<Usuario>)qu.getResultList();

                    log.debug("lu: " + lu);
                    log.debug("u.size: " + lu.size());

                    if (lu.size()>0) {
                        u = lu.get(0);
                        log.debug(u);
                        emailTo = u.getEmail();
                        nickTo = u.getNickMostrar();
                        esUsuario = true;
                    } else {
                        emailTo = "";
                    }
                } /* else {
                    emailTo = invitado;
                } */


                //if (!emailTo.equals("")) {
                if (esUsuario) { // El usuario existe en la bd
                    // Mandar mensaje interno, si no se ha enviado antes

                    if (!nicksEnviados.contains(u.getNick())) {
                        nicksEnviados.add(u.getNick());

                        // Es usuario, mandar mensaje interno
                        log.debug("Mandar mensaje interno");
                        log.debug("===============================");

                        MensajeUsuario mu = new MensajeUsuario();

                        Usuario ul = getUsuarioLogado();
                        mu.setSender(ul.getId());
                        log.debug("sender: " + ul.getId());
                        mu.setFrom(ul.getNickMostrar());
                        log.debug("from: " + ul.getNickMostrar());
                        mu.setFromUrl(ul.getNick());
                        log.debug("receiver: " + u.getId());
                        mu.setReceiver(u.getId());

                        // El promotor ha aplazado el partido
                        mu.setAsunto(getText("mail.torneos_de_usuario.invitacion.asunto"));
                        //mu.setTexto("El organizador ha decidido aplazar el partido entre " + cal.getEquipo1().getNombreCompleto() + " y " + cal.getEquipo2().getNombreCompleto() + " a la fecha " + faplazamiento);
                        String textoMensaje = getText("mail.torneos_de_usuario.invitacion.texto.registrado");
                        if (nickTo!="") {
                            textoMensaje = textoMensaje.replaceAll("#NICK#", " <strong>"+nickTo+"</strong>");
                        } else {
                            textoMensaje = textoMensaje.replaceAll("#NICK#", "");
                        }
                        textoMensaje = textoMensaje.replaceAll("#ORGANIZADOR#", torneo.getUsuario().getNickMostrar());
                        textoMensaje = textoMensaje.replaceAll("#URL_TORNEO#", torneo.getNombreUrl());
                        textoMensaje = textoMensaje.replaceAll("#NOMBRE_TORNEO#", torneo.getNombre());

                        mu.setTexto(textoMensaje);

                        mu.setTipoUsuarioEmisor(mu.TIPO_USUARIO_ADMINISTRADOR_TORNEO);
                        mu.setTipoDestinatario(0);

                        log.debug("escribir mensaje, pero no a temporada !!!");
                        escribirMensaje(mu);
                    }

                    if (mostrarError) {
                        setMensajeAlerta(getText("alertas.torneos_de_usuario.administrar.invitaciones_enviadas"));
                    }
                }

            }
        } catch (Exception e) {
            log.error("Error: ", e);
            if (mostrarError) {
                setMensajeAlerta(getText("alertas.torneos_de_usuario.administrar.invitaciones_enviadas_error"));
            }
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }


    public int getEstadoTorneo(int idTemporada) {

        /*
         * Devuelve el estado de un torneo de usuario:
         *
         *  0: libre para apuntarse y no comenzada
         *  1: completa y no comenzada
         *  2: comenzada
         *  3: no apto / error
         */

        int TEMPORADA_LIBRE = 0;
        int TEMPORADA_COMPLETA = 1;
        int TEMPORADA_COMENZADA = 2;
        int TEMPORADA_NO_APTO = 3;
        int TEMPORADA_INSCRITO = 4; // El administrador ha admitido al equipo
        int TEMPORADA_PARTICIPANDO = 5;
        int TEMPORADA_PENDIENTE = 6; // El administrador no ha admitido aún al equipo

        int retorno = TEMPORADA_LIBRE;

        boolean apto = false;
        boolean apuntado = false;
        boolean pendiente = false;

        EntityManager em = null;

        Usuario usuario = null;
        List<Equipo> equipos = null;

        try {
            log.debug("getEstadoTorneo [1]");
            em = emfBasket.createEntityManager(); // checked
            Temporada t = em.find(Temporada.class, idTemporada);
            usuario = getUsuarioLogado();
            if (usuario != null) {
                equipos = usuario.getEquipos();
            }

            log.debug("getEstadoTorneo [2] t: " + t);
            if (t!=null) {
                log.debug("getEstadoTorneo [3] t.getEstado: " + t.getEstado());
                if (t.getEstado()!= null && t.getEstado() < 2) {
                    // No ha comenzado aún

                    log.debug("getEstadoTorneo [4]: temporada: " + t);
                    log.debug("getEstadoTorneo [4] maxEquipos: " + t.getMaxEquipos());
                    log.debug("getEstadoTorneo [4] participes: " + t.getParticipeList());
                    
                    if (t.getParticipeList().size() < t.getMaxEquipos()) {

                        log.debug("getEstadoTorneo [5]");

                        if (usuario != null) {
                            for (Equipo equipo : equipos) {
                                if (equipo.getNivel() >= t.getNivelIni()
                                        && equipo.getNivel() <= t.getNivelFin()) {
                                    apto = true;
                                }

                                log.debug("getEstadoTorneo [6]");

                                int estadoEquipoTorneo = getEstadoEquipoTorneo(equipo.getId(), idTemporada);
                                if (estadoEquipoTorneo == 0) {
                                    pendiente = true;
                                } else if (estadoEquipoTorneo == 1) {
                                    apuntado = true;
                                }
                            }

                            if (!apto) {
                                retorno = TEMPORADA_NO_APTO;
                            } else {
                                if (apuntado) {
                                    retorno = TEMPORADA_INSCRITO;
                                } else {
                                    if (pendiente) {
                                        retorno = TEMPORADA_PENDIENTE;
                                    } else {
                                        retorno = TEMPORADA_LIBRE;
                                    }
                                }
                            }
                        } else {
                            retorno = TEMPORADA_LIBRE;
                        }
                    } else {
                        log.debug("getEstadoTorneo [6]");
                        int estadoUsuarioTorneo = getEstadoUsuarioTorneo(t.getId());
                        if (estadoUsuarioTorneo == 0) {
                            retorno = TEMPORADA_PENDIENTE;
                        } else if (estadoUsuarioTorneo == 1) {
                            retorno = TEMPORADA_INSCRITO;
                        } else {
                            retorno = TEMPORADA_COMPLETA;
                        }
                    }
                } else {
                    if (usuario != null) {
                        for (Equipo equipo : equipos) {
                            if (equipo.getNivel() >= t.getNivelIni()
                                    && equipo.getNivel() <= t.getNivelFin()) {
                                apto = true;
                            }

                            int estadoEquipoTorneo = getEstadoEquipoTorneo(equipo.getId(), idTemporada);
                            if (estadoEquipoTorneo == 0) {
                                pendiente = true;
                            } else if (estadoEquipoTorneo == 1) {
                                apuntado = true;
                            }
                        }

                        if (apuntado) {
                            retorno = TEMPORADA_PARTICIPANDO;
                        } else {
                            retorno = TEMPORADA_COMENZADA;
                        }
                    } else {
                        retorno = TEMPORADA_COMPLETA;
                    }
                }
            }
        } catch (NoResultException nre) {
            log.error("1", nre);
        } catch (Exception e) {
            log.error("2", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

    private int getEstadoUsuarioTorneo(int idTemporada) {
        int retorno = -1;

        try {
            Usuario usuario = getUsuarioLogado();

            if (usuario != null) {
                List<Equipo> equipos = usuario.getEquipos();
                for (Equipo equipo : equipos) {
                    int estadoEquipoTorneo = getEstadoEquipoTorneo(equipo.getId(), idTemporada);
                    if (estadoEquipoTorneo <= 1) {
                        retorno = estadoEquipoTorneo;
                    }
                }
            }
        } catch (Exception e) {
            log.error(e);
        }

        return retorno;
    }

    private int getEstadoEquipoTorneo(int idEquipo, int idTemporada) {
        int retorno = -1;

        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked
            Query q = em.createNamedQuery("Participe.findByEquipoIdTemporadaId");
            q.setParameter("idEquipo", idEquipo);
            q.setParameter("idTemporada", idTemporada);

            if (q.getResultList().size()>0) {
                // No hay registros
                Participe p = ((List<Participe>)q.getResultList()).get(0);
                retorno = p.getEstado();
            }
        } catch (NoResultException nre) {
            log.error("1", nre);
        } catch (Exception e) {
            log.error("2", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }
    

    public String consultar() {
        String retorno = SUCCESS;

        obtenerTorneo(false);
        obtenerParticipes();

        if (temporada != null) {
            log.debug("estaod: " + temporada.getEstado());
            if (temporada.getEstado() < 2) { // No ha empezado aún
                retorno = previa();
            } else {
                obtenerCalendario();
                retorno = inicio();
            }
        } else {
            retorno = NOT_FOUND;
        }

        return retorno;
    }

    public void obtenerTorneo() {
        obtenerTorneo(false);
    }

    public void obtenerTorneo(boolean estadisticas) {
        EntityManager em = null;

        //log.debug("obtenerTorneo: " + urlTorneo);

        try {

            em = emfBasket.createEntityManager(); // checked

            log.debug(">>>>>>>>>>>>>> buscando " + urlTorneo);

            Query q = em.createNamedQuery("Torneo.findById");
            q.setParameter("id", Integer.parseInt(urlTorneo));
            Torneo torneo = (Torneo)q.getSingleResult();

            q = em.createNamedQuery("Temporada.findTemporadaActivaByTorneoId");
            q.setParameter("id", torneo.getId());
            q.setMaxResults(1);
            Temporada temporada = (Temporada)q.getSingleResult();

            setTorneo(torneo);
            setTemporada(temporada);

            // Calcular jornada en curso
            Date hoy = new Date();

            jornadaEnCurso = null;
            //log.debug(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CALCULAR JORNADA EN CURSO <<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
            Jornada ultimaJornada = null;
            for(Jornada j : temporada.getJornadaList()) {
                //log.debug("fini: " + j.getFIni() + ", ffin: " + j.getFFin());
                if (j.getFIni().compareTo(hoy)<0 && j.getFFin().compareTo(hoy)>0) {
                    setJornadaEnCurso(j);
                }
                ultimaJornada = j;
            }


            log.debug(">>>>>>>>>>>>>>> ultimaJornada: " + ultimaJornada);

            if (jornadaEnCurso==null) {
                // O no ha empezado el torneo, o se ha terminado
                
                log.debug("finicio: " + temporada.getFInicio());
                log.debug("ffin: " + temporada.getfFinPrevista());
                log.debug("hoy: " + hoy);
                if (temporada.getFFin()!=null) {
                    //log.debug("compare: " + temporada.getFInicio().compareTo(hoy));
                    if (temporada.getFInicio().compareTo(hoy)>0) {
                        setTemporadaIniciada(false);
                        setJornadaEnCurso((Jornada)temporada.getJornadaList().get(0));
                    } else if (temporada.getfFinPrevista()!=null && temporada.getfFinPrevista().compareTo(hoy)<0) {
                        setTemporadaFinalizada(true);
                        setJornadaEnCurso(ultimaJornada);
                    }
                } else {
                    setTemporadaIniciada(false);
                    //setJornadaEnCurso((Jornada)temporada.getJornadaList().get(0));
                }
            }

            log.debug(">>>>>>>>>>>>>>>>>>>> JORNADA EN CURSO: " + getJornadaEnCurso());

            //log.debug("............. leyendo mensajes torneo");
            setListaMensajesTorneo(leerMensajesTorneo(temporada.getId()));
            //log.debug(">>> " + getListaMensajesTorneo());

            if (estadisticas) {
                calcularAnotacionTorneo();
                calcularAsistenciasTorneo();
                calcularRebotesTorneo();
                calcularRecuperacionesTorneo();
                calcularTaponesTorneo();
                calcularValoracionTorneo();
            }

            log.debug("fijando lunes: " + torneo.getNombreUrl());
            setUrlRedirect(torneo.getNombreUrl());
            
        } catch (NoResultException nre) {
            log.debug("No se ha encontrado el torneo 1 " + urlTorneo);
        } catch (Exception e) {
            log.error("", e);
            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }


    public void obtenerTorneoPorId() {
        EntityManager em = null;

        try {

            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Torneo.findById");
            q.setParameter("id", idTorneo);
            Torneo torneo = (Torneo)q.getSingleResult();

            q = em.createNamedQuery("Temporada.findTemporadaActivaByTorneoId");
            q.setParameter("id", torneo.getId());
            q.setMaxResults(1);
            Temporada temporada = (Temporada)q.getSingleResult();

            setTorneo(torneo);
            setTemporada(temporada);

            setListaMensajesTorneo(leerMensajesTorneo(temporada.getId()));
        } catch (NoResultException nre) {
            log.debug("No se ha encontrado el torneo con id " + idTorneo);
        } catch (Exception e) {
            log.error("", e);
            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }



    public void obtenerPartidosPendientes(int idTemporada, int idUsuario) {
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Calendario.findByTemporadaIdUsuarioId");
            q.setParameter("idTemporada", idTemporada);
            q.setParameter("idUsuario", idUsuario);
            List<Calendario> lCal = (List<Calendario>)q.getResultList();

            DatosCalendarioTorneo dt = null;
            List<Calendario> partidos = null;

            int antJor = 0;

            //log.debug("lCal: " + lCal);

            partidosPendientes = new ArrayList<DatosCalendarioTorneo>();

            for(Calendario cal : lCal) {
                int nJor = cal.getJornada().getNumero();
                //int nJor = cal.getNumJornada();
                //log.debug("comparando " + nJor + " con " + antJor);
                if (nJor != antJor) {

                    // Nueva jornada
                    antJor = nJor;

                    if (dt!=null) {
                        dt.setPartidos(partidos);
                        partidosPendientes.add(dt);
                    }

                    dt = new DatosCalendarioTorneo();
                    dt.setNumJornada(nJor);
                    //dt.setFecha(cal.getJornada().getFIni());
                    dt.setFecha(cal.getFIni());
                    dt.setFechaInicio(cal.getFIni());

                    partidos = new ArrayList<Calendario>();
                }

                partidos.add(cal);
            }

            if (dt!=null) {
                if (partidos!=null) {
                    dt.setPartidos(partidos);
                }
                partidosPendientes.add(dt);
                //setPartidosPendientes(partidosPendientes);
            }

        } catch (NoResultException nre) {
            log.debug("No se ha encontrado el torneo  2 " + urlTorneo);
        } catch (Exception e) {
            log.error("", e);
            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }



    public void obtenerPartidosPendientesAdministrador(int idTemporada) {
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Calendario.findPendientesAdministrador");
            q.setParameter("idTemporada", idTemporada);
            List<Calendario> lCal = (List<Calendario>)q.getResultList();

            DatosCalendarioTorneo dt = null;
            List<Calendario> partidos = null;

            int antJor = 0;

            List<DatosCalendarioTorneo> partidosCalendarioAux = new ArrayList<DatosCalendarioTorneo>();

            for(Calendario cal : lCal) {
                int nJor = cal.getJornada().getNumero();
                if (nJor != antJor) {

                    // Nueva jornada
                    antJor = nJor;

                    if (dt!=null) {
                        dt.setPartidos(partidos);
                        partidosCalendarioAux.add(dt);
                    }

                    dt = new DatosCalendarioTorneo();
                    dt.setNumJornada(nJor);
                    dt.setFecha(cal.getFIni());
                    dt.setFechaInicio(cal.getFIni());

                    partidos = new ArrayList<Calendario>();
                }

                partidos.add(cal);
            }

            if (partidos!=null) {
                dt.setPartidos(partidos);
                partidosCalendarioAux.add(dt);
                setPartidosPendientesAdministrador(partidosCalendarioAux);
            }

        } catch (NoResultException nre) {
            log.debug("No se ha encontrado el torneo 3 " + urlTorneo);
        } catch (Exception e) {
            log.error("", e);
            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }


    public void obtenerCalendario() {
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Calendario.findByTemporadaId");
            q.setParameter("temporadaId", temporada.getId());
            List<Calendario> lCal = (List<Calendario>)q.getResultList();

            DatosCalendarioTorneo dt = null;
            List<Calendario> partidos = null;

            int antJor = 0;

            log.debug("lCal: " + lCal);

            partidosCalendario = new ArrayList<DatosCalendarioTorneo>();

            for(Calendario cal : lCal) {
                int nJor = cal.getJornada().getNumero();
                //int nJor = cal.getNumJornada();
                log.debug("comparando " + nJor + " con " + antJor);
                if (nJor != antJor) {
                    
                    // Nueva jornada
                    antJor = nJor;

                    if (dt!=null) {
                        dt.setPartidos(partidos);
                        partidosCalendario.add(dt);
                    }

                    dt = new DatosCalendarioTorneo();
                    dt.setNumJornada(nJor);
                    //dt.setFecha(cal.getJornada().getFIni());
                    dt.setFecha(cal.getFIni());
                    dt.setFechaInicio(cal.getFIni());

                    partidos = new ArrayList<Calendario>();
                }

                partidos.add(cal);
            }

            dt.setPartidos(partidos);
            partidosCalendario.add(dt);
            log.debug(">>>>>>>>>>>> jarl lunes " + partidosCalendario);
            setPartidosCalendario(partidosCalendario);

            // Fijar los partidos de la jornada actual

            log.debug(">>>>>>>>> JORNADA REQUEST: " + jornada);

            if (jornada==0) {
                if (jornadaEnCurso!=null) {
                    jornada = jornadaEnCurso.getNumero();
                }
            }

            //log.debug(">>>>>>>>> JORNADA REQUEST: " + jornada);

            List<DatosCalendarioTorneo> aux = new ArrayList<DatosCalendarioTorneo>();
            for(DatosCalendarioTorneo dc:partidosCalendario) {
                if (dc.getNumJornada()==jornada) {
                    //log.debug(">>>>>>>>>>> Añadiendo jornada " + jornada);
                    aux.add(dc);
                }
            }
            setPartidosCalendarioJornada(aux);

            // Obtener ahora el calendario del "carrusel" de la home de torneos
            /*
            List<DatosCalendarioTorneo> carruselAux = new ArrayList<DatosCalendarioTorneo>();
            int nj = 0;
            int antJ = 0;
            int numPartidosCarrusel = 0;
            for(DatosCalendarioTorneo dc:partidosCalendario) {
                DatosCalendarioTorneo dctaux = new DatosCalendarioTorneo();
                dctaux.setFecha(dc.getFecha());
                dctaux.setNumJornada(dc.getNumJornada());
                ArrayList<Calendario> acaux = null;
                for(Calendario c:dc.getPartidos()) {
                    if (numPartidosCarrusel<4) {
                        numPartidosCarrusel++;
                        if (acaux==null) {
                            acaux = new ArrayList<Calendario>();
                        }
                        //log.debug("carrusel: " + c);
                        Calendario cux = new Calendario();
                        cux = c;
                        //log.debug("antes carrusel: " + acaux);
                        acaux.add(cux);
                        //log.debug("despues carrusel: " + acaux);
                        //log.debug("el partido: " + c.getPartido());
                        //log.debug("el partido 2: " + cux.getPartido());
                        if (c.getJornada().getNumero()>antJ) {
                            nj++;
                            antJ = c.getJornada().getNumero();
                        }
                    }
                }
                //log.debug("acaux: " + acaux);
                if (acaux != null) {
                    //log.debug("acaux[0].partidos: " + acaux.get(0).getPartido());
                    dctaux.setPartidos(acaux);
                    carruselAux.add(dctaux);
                }
            }
            setNumJornadasCarrusel(nj);
            //log.debug("Carrusel aux: " + carruselAux);
            setPartidosCalendarioCarrusel(carruselAux);
             * 
             */

            //log.debug("Carrusel aux: " + carruselAux.get(0).getPartidos());

        } catch (NoResultException nre) {
            log.debug("No se ha encontrado el torneo 4 " + urlTorneo);
        } catch (Exception e) {
            log.error("", e);
            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }

    public void obtenerClasificacion(boolean soloTres) {
        EntityManager em = null;

        //log.debug("buscando clasificacion ...");

        try {

            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Participe.clasificacionTemporada");
            q.setParameter("temporadaId", temporada.getId());
            if (soloTres) {
                q.setMaxResults(3);
            }
            //log.debug("antes de set");
            setClasificacion((List<Participe>)q.getResultList());
            //log.debug(">>> " + listaAdmitidos);

        } catch (NoResultException nre) {
            log.debug("No se ha encontrado la clasificacion " + urlTorneo);
        } catch (Exception e) {
            log.error("", e);
            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }

/*
    public void obtenerCalendarioScroll() {
        EntityManager em = null;

        int MAX_PARTIDOS_MOSTRAR = 6;
        int MAX_PARTIDOS_MOSTRAR_CENTRO = 6;

        try {
            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Calendario.findByTemporadaId");
            q.setParameter("temporadaId", temporada.getId());
            List<Calendario> lCal = (List<Calendario>)q.getResultList();

            DatosCalendario dt = null;
            List<DatosCalendarioPartido> partidos = null;
            partidos = new ArrayList<DatosCalendarioPartido>();

            int antJor = 0;

            calendario = new ArrayList<DatosCalendario>();

            int nPartidos = 0;

            log.debug("antes del for, lCal: " + lCal);
            
            for(Calendario cal : lCal) {
                int nJor = cal.getJornada().getNumero();
                //int nJor = cal.getNumJornada();
                log.debug("nJor: " + nJor);
                if (nJor != antJor) {
                    // Nueva jornada
                    antJor = nJor;

                    log.debug("Nueva jornada, dt: " + dt);

                    if (dt!=null) {
                        dt.setPartidos(partidos);
                        log.debug("añadiendo a calendario 1 ... " + dt);
                        calendario.add(dt);
                    }

                    dt = new DatosCalendario();
                    DateFormat df = new SimpleDateFormat("dd/MM");
                    DateFormat dd = new SimpleDateFormat("yyyyMMdd");
                    //dt.setFecha(df.format(cal.getJornada().getFIni()));
                    //dt.setDia(dd.format(cal.getJornada().getFIni()));
                    dt.setFecha(df.format(cal.getFIni()));
                    dt.setDia(dd.format(cal.getFIni()));

                    partidos = new ArrayList<DatosCalendarioPartido>();
                }

                DatosCalendarioPartido dcp = new DatosCalendarioPartido();
                
                DatosCalendarioEquipo de1 = new DatosCalendarioEquipo();
                de1.setAbreviatura(cal.getEquipo1().getNombre());
                de1.setNombre(cal.getEquipo1().getNombre());
                de1.setNick(cal.getEquipo1().getNick());
                de1.setLogoimgId(cal.getEquipo1().getAspecto().getLogoimgId());
                de1.setNombreUrl(cal.getEquipo1().getNombreUrl());
                de1.setUsuario(cal.getEquipo1().getUsuario().getId());

                DatosCalendarioEquipo de2 = new DatosCalendarioEquipo();
                de2.setAbreviatura(cal.getEquipo2().getNombre());
                de2.setNombre(cal.getEquipo2().getNombre());
                de2.setNick(cal.getEquipo2().getNick());
                de2.setLogoimgId(cal.getEquipo2().getAspecto().getLogoimgId());
                de2.setNombreUrl(cal.getEquipo2().getNombreUrl());
                de2.setUsuario(cal.getEquipo2().getUsuario().getId());

                dcp.setEquipo_1(de1);
                dcp.setEquipo_2(de2);
                dcp.setEstado("0");
                dcp.setResultado("1|2");

                if (nPartidos<MAX_PARTIDOS_MOSTRAR) {
                    partidos.add(dcp);
                    nPartidos++;
                } else {
                    break;
                }
            }

            dt.setPartidos(partidos);
            log.debug("añadiendo a calendario ... " + dt);
            calendario.add(dt);
            setCalendario(calendario);

        } catch (NoResultException nre) {
            log.debug("No se ha encontrado el torneo " + urlTorneo);
        } catch (Exception e) {
            log.error("", e);
            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }
 * 
 */


    public String inicio() {
        obtenerCalendario();
        obtenerClasificacion(true);
        if (getUsuarioLogado()!=null && temporada != null) {
            obtenerPartidosPendientes(temporada.getId(), getUsuarioLogado().getId());
            obtenerPartidosPendientesAdministrador(temporada.getId());
        }
        //obtenerCalendarioScroll();
        return TORNEO_INICIO;
    }

    public String administrar() {
        obtenerTorneo();
        
        if (getUsuarioLogado()!=null && temporada != null) {
            //obtenerPartidosPendientes(temporada.getId(), getUsuarioLogado().getId());
            obtenerPartidosPendientesAdministrador(temporada.getId());
        }

        return SUCCESS;
    }

    public String tomarDecision() {

        String retorno = SUCCESS;

        resultadoAdministracion = 1;

        //log.debug("Tomar decision");
        //log.debug("accion: " + accion);
        //log.debug("fecha: " + fecha_aplazamiento);

        obtenerTorneoPorId();

        //log.debug("Torneo: " + torneo);
        
        // Comprobar que el torneo es del usuario
        
        if (torneo!=null) {
            //log.debug("usuarioLogado: " + getUsuarioLogado());
            if (getUsuarioLogado()!=null) {
                //log.debug("id usuario: " + getUsuarioLogado().getId());
                //log.debug("id administrador: " + torneo.getUsuario().getId());

                int idUsuario = getUsuarioLogado().getId();
                int idAdministrador = torneo.getUsuario().getId();

                if (getUsuarioLogado().getId().compareTo(torneo.getUsuario().getId())==0) {
                //if (idUsuario==idAdministrador) {
                    //log.debug("El usuario logado es administrador");

                    // Ver si el partido es del torneo

                    EntityManager em = null;

                    try {
                        em = emfBasket.createEntityManager(); // checked

                        Calendario cal = em.find(Calendario.class, idPartido);
                        //log.debug("calendario: " + cal);
                        
                        // Actuar según decisión

                        if (accion.equals("simular")) {
                            simularPartido(cal,0,0,3);
                        } else if (accion.equals("ganador-casa")) {
                            simularPartido(cal,10,0,3);
                        } else if (accion.equals("ganador-fuera")) {
                            simularPartido(cal,0,10,3);
                        } else if (accion.equals("perdido")) {
                            simularPartido(cal,0,0,2); // Perdido a ambos
                        } else if (accion.equals("aplazar")) {
                            aplazarPartido(cal,fecha);
                        }
                        
                    } catch (Exception e) {
                        log.error("Error: ", e);
                        retorno = ERROR;
                    } finally {
                        try { em.close(); } catch (Exception e) { }
                    }
                } else {
                    //log.debug("el usuario no es administrador :-|");
                    retorno = ERROR;
                }
            } else {
                retorno = ERROR;
            }
        } else {
            retorno = ERROR;
        }

        if (!retorno.equals(SUCCESS)) {
            resultadoAdministracion = 0;
        }

        return retorno;
    }


    private void aplazarPartido(Calendario calendario, String fecha) {

        EntityManager em = null;
        
        try {
            em = emfBasket.createEntityManager();

            // buscamos el calendario
            Query q = em.createNamedQuery("Calendario.findById");
            q.setParameter("id", calendario.getId());
            Calendario cal = (Calendario)q.getSingleResult();

            if ( cal != null) {
                DateFormat df = new SimpleDateFormat("dd/MM/yyyy");
                Date faplazamiento = df.parse(fecha_aplazamiento);

                //log.debug("faplazamiento: " + fecha_aplazamiento);
                //log.debug("ffin: " + cal.getFFin());
                //log.debug("ffinprevista: " + temporada.getfFinPrevista());
                //log.debug("Comparando ... " + faplazamiento.compareTo(cal.getFFin()));
                //log.debug("Comparando (2) ... " + faplazamiento.compareTo(temporada.getfFinPrevista()));

                GregorianCalendar fMaximaAplazamiento = new GregorianCalendar();
                fMaximaAplazamiento.setTime(temporada.getfFinPrevista());
                fMaximaAplazamiento.add(GregorianCalendar.DATE, 15);

                //log.debug("Comparando (3) ... " + faplazamiento.compareTo(fMaximaAplazamiento.getTime()));

                if (faplazamiento.compareTo(cal.getFFin())<0) {
                    setMensajeAlerta(getText("alertas.torneos_de_usuario.administrar.error_fecha_aplazamiento_pronto"));
                } else if (faplazamiento.compareTo(fMaximaAplazamiento.getTime())>0) {
                    setMensajeAlerta(getText("alertas.torneos_de_usuario.administrar.error_fecha_aplazamiento_tarde"));
                } else {
                    // Todo correcto

                    em.getTransaction().begin();

                    cal.setFFin(faplazamiento);
                    cal.setEstado((short)Calendario.ESTADO_APLAZADO);
                    temporada = em.find(Temporada.class, temporada.getId());
                    temporada.setFFin(faplazamiento);

                    em.persist(cal);
                    em.persist(temporada);
                    em.getTransaction().commit();
                    
                    // Escribir el mensaje de aplazamiento

                    MensajeUsuario mu = new MensajeUsuario();

                    Usuario ul = getUsuarioLogado();
                    mu.setSender(ul.getId());
                    mu.setFrom(ul.getNickMostrar());
                    mu.setFromUrl(ul.getNick());
                    mu.setReceiver(temporada.getId());

                    // El promotor ha aplazado el partido
                    mu.setAsunto(getText("competicion.torneo_de_usuario.administracion.mensaje_administrador.partido_aplazado.titulo"));
                    //mu.setTexto("El organizador ha decidido aplazar el partido entre " + cal.getEquipo1().getNombreCompleto() + " y " + cal.getEquipo2().getNombreCompleto() + " a la fecha " + faplazamiento);
                    List<Object> l = new ArrayList<Object>();
                    l.add(cal.getEquipo1().getNombreCompleto());
                    l.add(cal.getEquipo2().getNombreCompleto());
                    l.add(faplazamiento);

                    String textoMensaje = getText("competicion.torneo_de_usuario.administracion.mensaje_administrador.partido_aplazado.texto",l);
                    mu.setTexto(textoMensaje);

                    mu.setTipoUsuarioEmisor(mu.TIPO_USUARIO_ADMINISTRADOR_TORNEO);
                    mu.setTipoDestinatario(1);

                    escribirMensajeTorneo(mu);
                }
                
            }
        } catch (Exception e) {
            log.error("Error: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }

    private void escribirMensajeTorneo(MensajeUsuario mu) {
        if ( esParticipe(mu.getSender()) || torneo.getUsuario().getId().equals(mu.getSender()) ) {
            escribirMensaje(mu);
        }
    }

    private void simularPartido(Calendario cal, int tanteo1, int tanteo2, int estadoPartido) {

        EntityManager em = null;
        boolean simulado = false;
        try {
            em = emfBasket.createEntityManager();

            int idPartido = 0;

            if (estadoPartido!=2) {
                while (tanteo1==tanteo2) {
                    simulado = true;
                    tanteo1 = (int)(Math.random()*20+20);
                    tanteo2 = (int)(Math.random()*20+20);
                }
            }

            actualizarTorneoUsuario(cal.getId(), idPartido, estadoPartido, new Date(), tanteo1, tanteo2);

            // Escribir los mensajes en el muro :-)

            MensajeUsuario mu = new MensajeUsuario();

            Usuario ul = getUsuarioLogado();
            mu.setSender(ul.getId());
            mu.setFrom(ul.getNickMostrar());
            mu.setFromUrl(ul.getNick());
            mu.setReceiver(temporada.getId());

            //log.debug("simulado: " + simulado);
            //log.debug("estadoPartido: " + estadoPartido);
            //log.debug("tanteo1: " + tanteo1);
            //log.debug("tanteo2: " + tanteo2);

            if (simulado) {
                // El promotor ha simulado el partido
                mu.setAsunto(getText("competicion.torneo_de_usuario.administracion.mensaje_administrador.partido_simulado.titulo"));
                List<Object> l = new ArrayList<Object>();
                l.add(cal.getEquipo1().getNombreCompleto());
                l.add(cal.getEquipo2().getNombreCompleto());
                l.add(tanteo1);
                l.add(tanteo2);
                mu.setTexto(getText("competicion.torneo_de_usuario.administracion.mensaje_administrador.partido_simulado.texto",l));

                mu.setTipoUsuarioEmisor(mu.TIPO_USUARIO_ADMINISTRADOR_TORNEO);
                mu.setTipoDestinatario(1);

                escribirMensajeTorneo(mu);
            } else if (estadoPartido==3) {
                mu.setAsunto(getText("competicion.torneo_de_usuario.administracion.mensaje_administrador.partido_decidido.titulo"));
                List<Object> l = new ArrayList<Object>();
                l.add(cal.getEquipo1().getNombreCompleto());
                l.add(cal.getEquipo2().getNombreCompleto());
                if (tanteo1>tanteo2) {
                    l.add(cal.getEquipo1().getNombreCompleto());
                } else {
                    l.add(cal.getEquipo2().getNombreCompleto());
                }
                mu.setTexto(getText("competicion.torneo_de_usuario.administracion.mensaje_administrador.partido_decidido.texto",l));

                mu.setTipoUsuarioEmisor(mu.TIPO_USUARIO_ADMINISTRADOR_TORNEO);
                mu.setTipoDestinatario(1);

                escribirMensajeTorneo(mu);
            } else if (estadoPartido==2) { // Perdidos los dos
                mu.setAsunto(getText("competicion.torneo_de_usuario.administracion.mensaje_administrador.partido_perdido.titulo"));
                List<Object> l = new ArrayList<Object>();
                l.add(cal.getEquipo1().getNombreCompleto());
                l.add(cal.getEquipo2().getNombreCompleto());
                mu.setTexto(getText("competicion.torneo_de_usuario.administracion.mensaje_administrador.partido_perdido.texto",l));

                mu.setTipoUsuarioEmisor(mu.TIPO_USUARIO_ADMINISTRADOR_TORNEO);
                mu.setTipoDestinatario(1);

                escribirMensajeTorneo(mu);

            }
        } catch (Exception e) {
            log.error("Error: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }

    private void actualizarTorneoUsuario( int idCalendario, int idPartido,
            int estado, Date fecha, int tanteo1, int tanteo2 ) {

        // Actualiza el resultado de un partido de un torneo de usuario
        // Si el estado pasado como parÃ¡metro es:
        //       1 actualiza el enfrentamiento como un partido jugado con normalidad
        //       2 perdido por ambos
        //       3 ganador decidido por el promotor

        EntityManager em = emfBasket.createEntityManager();

        // buscamos el calendario
        Query q = em.createNamedQuery("Calendario.findById");
        q.setParameter("id", idCalendario );
        Calendario cal = (Calendario)q.getSingleResult();

        if ( cal != null) {
            // actualizamos f_partido, tanteos y estado
            cal.setFPartido(fecha);
            cal.setTanteo1((short)tanteo1);
            cal.setTanteo2((short)tanteo2);
            cal.setEstado((short)12); // partido decido por el promotor
            //cal.setPartido(null);
            short ganados1=0,ganados2=0,perdidos1=0,perdidos2=0,puntos1=1,puntos2=1;

            em.getTransaction().begin();
            em.persist(cal);
            em.getTransaction().commit();

            switch ( estado) {
                case 1:
                    if (tanteo1>tanteo2) {
                        puntos1 = 2;
                        puntos2 = 1;
                        ganados1 = 1;
                        perdidos2 = 1;
                    } else {
                        puntos2 = 2;
                        puntos1 = 1;
                        ganados2 = 1;
                        perdidos1 = 1;
                    }
                    break;
                case 3:
                    if (tanteo1>tanteo2) {
                        puntos1 = 2;
                        puntos2 = 0;
                        ganados1 = 1;
                        perdidos2 = 1;
                    } else {
                        puntos2 = 2;
                        puntos1 = 0;
                        ganados2 = 1;
                        perdidos1 = 1;
                    }
                    break;
                case 2:
                    perdidos1 = 1;
                    perdidos2 = 1;
                    puntos1 = 0;
                    puntos2 = 0;
                    break;
                }

            // buscamos a los dos participles y
            // Actualizamos ganados, perdidos, puntos, y favor/contra
            actualizarParticipe( cal.getEquipo1().getId(), cal.getTemporada().getId(),
                    puntos1, ganados1, perdidos1, tanteo1, tanteo2 );
            actualizarParticipe( cal.getEquipo2().getId(), cal.getTemporada().getId(),
                  puntos2, ganados2, perdidos2, tanteo2, tanteo1 );
        }
    }

    private void actualizarParticipe(int idEquipo, int idTemporada, int puntos,
            short ganados, short perdidos,  int favor, int contra ) {

        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager();
            //log.debug("Buscando Participe "+ idEquipo + " "+ idTemporada+ " PUNTOS"+puntos);
            Query qp = em.createNamedQuery("Participe.findByEquipoIdTemporadaId");
            qp.setParameter("idEquipo", idEquipo);
            qp.setParameter("idTemporada", idTemporada  );
            Participe participe = (Participe)qp.getSingleResult();

            //log.debug("participe encontrado: " + participe);
            //log.debug("equipo: " + participe.getEquipo());
            //log.debug("idEquipo: " + participe.getEquipo().getId());
            
            if ( participe != null ) {
                participe.setFavor  (participe.getFavor ()+favor);
                participe.setContra (participe.getContra()+contra);

                participe.setGanados((short)(participe.getGanados()+ganados));
                participe.setPerdidos((short)(participe.getPerdidos()+perdidos));
                participe.setPuntos(participe.getPuntos()+puntos);

                //log.debug("persistiendo ...");

                em.getTransaction().begin();
                em.persist(participe);
                em.getTransaction().commit();
            } else {
                log.info("Partícipe no encontrado");
            }
        } catch (Exception e) {
            log.error("Error:",e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

    }

    private void abandonarTorneo() {

        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager();

            if (getUsuarioLogado()!=null) {
                // Hay usuario logado
                if (esParticipe(getUsuarioLogado().getId())) {
                    // El usuario logado participa en el torneo

                    // Mandar mensaje al organizador pidiendo el abandono del torneo

                    Participe p1 = dameParticipe(getUsuarioLogado().getId());

                    if (p1!=null && p1.getEstado()!=13) { // No ha enviado antes el mensaje

                        MensajeUsuario mu = new MensajeUsuario();

                        Usuario ul = getUsuarioLogado();
                        mu.setSender(ul.getId());
                        mu.setFrom(ul.getNickMostrar());
                        mu.setFromUrl(ul.getNick());
                        mu.setReceiver(torneo.getUsuario().getId());

                        log.debug("Mandar mensaje a usuario : " + torneo.getUsuario().getId());

                        // El promotor ha aplazado el partido
                        mu.setAsunto(getText("mensaje_interno.torneos_de_usuario.administracion.peticion_abandono.titulo"));
                        List<Object> l = new ArrayList<Object>();
                        l.add(getUsuarioLogado().getNickMostrar());
                        l.add(torneo.getNombreUrl());
                        l.add(torneo.getNombre());

                        String textoMensaje = getText("mensaje_interno.torneos_de_usuario.administracion.peticion_abandono.mensaje",l);
                        mu.setTexto(textoMensaje);

                        mu.setTipoUsuarioEmisor(mu.TIPO_USUARIO_ADMINISTRADOR_TORNEO);
                        mu.setTipoDestinatario(mu.TIPO_USUARIO_NORMAL);

                        escribirMensajeTorneo(mu);

                        Query q = em.createNamedQuery("Participe.findByEquipoIdTemporadaId");
                        q.setParameter("idEquipo", p1.getEquipo().getId());
                        q.setParameter("idTemporada", p1.getTemporada().getId());
                        log.debug("lunex: buscando participe en bd");
                        Participe pdb = (Participe)q.getSingleResult();
                        log.debug("lunex: encontrado en bd: " + pdb);

                        em.getTransaction().begin();
                        pdb.setEstado((short)13); // Estado 13 -> solicita expulsión
                        em.persist(pdb);
                        em.getTransaction().commit();

                        setMensajeAlerta(getText("alertas.torneos_de_usuario.administrar.abandonar.confirmacion"));
                    }
                }
            }
        } catch (Exception e) {
            log.debug("Error en abandonar torneo: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }


    }

    private void expulsarTorneo() {

        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager();

            // Actualizar el estado de los participes

            for (String url : elegir_equipo) {
                em.getTransaction().begin();

                Query q = em.createNamedQuery("Equipo.findByNombreUrl");
                q.setParameter("nombre", url);
                Equipo equipoExpulsado = (Equipo)q.getSingleResult();

                q = em.createNamedQuery("Participe.findByEquipoIdTemporadaId");
                q.setParameter("idEquipo", equipoExpulsado.getId());
                q.setParameter("idTemporada", temporada.getId());
                Participe participeExpulsado = (Participe)q.getSingleResult();

                participeExpulsado.setEstado((short)11);
                participeExpulsado.setPuntos(0);

                em.persist(participeExpulsado);

                em.getTransaction().commit();
            }


            boolean hayExpulsion = false; // Para mostrar el mensaje de alerta

            if (getUsuarioLogado()!=null) {
                // Hay usuario logado
                //log.debug("usaurio logado: " + getUsuarioLogado().getId());
                //log.debug("administarador: " + torneo.getUsuario().getId());
                if (torneo.getUsuario().getId().equals(getUsuarioLogado().getId())) {
                    // El usuario es el administrador del torneo

                    // Recorrer todo el calendario, y los partidos pendientes del usuario, dárselos por perdidos

                    if (partidosCalendario!=null) {
                        for(DatosCalendarioTorneo listaCalendario : partidosCalendario) {
                            for(Calendario partido : listaCalendario.getPartidos()) {
                                // Ver si el equipoUrl coincide con algunos de los expulsados

                                //log.debug("comprobando partido entre " + partido.getEquipo1().getNombreUrl() + " y " + partido.getEquipo2().getNombreUrl());

                                boolean expulsadoCasa = false;
                                boolean expulsadoFuera = false;

                                for (String url : elegir_equipo) {
                                    if (partido.getEquipo1().getNombreUrl().equals(url)) {
                                        expulsadoCasa = true;
                                    } else if (partido.getEquipo2().getNombreUrl().equals(url)) {
                                        expulsadoFuera = true;
                                    }
                                }

                                //log.debug("expulsados: " + expulsadoCasa + "-" + expulsadoFuera);
                                //log.debug("==========================");

                                if ( expulsadoCasa || expulsadoFuera ) {

                                    hayExpulsion = true;

                                    // El partido es para expulsar a alguno

                                    if ( (partido.getEstado() == Calendario.ESTADO_NO_JUGADO) || (partido.getEstado() == Calendario.ESTADO_APLAZADO)) {
                                        //log.debug("El partido hay que darlo por perdido");

                                        int tanteo1 = 0;
                                        int tanteo2 = 0;

                                        if (expulsadoCasa && expulsadoFuera) {
                                            // Lo pierden los dos (estado = 2)
                                            actualizarTorneoUsuario(partido.getId(), 0, 2, new Date(), tanteo1, tanteo2);
                                        } else if (expulsadoCasa) {
                                            // Lo pierde el de casa (estado = 3)
                                            tanteo2 = 10;
                                            actualizarTorneoUsuario(partido.getId(), 0, 3, new Date(), tanteo1, tanteo2);
                                        } else {
                                            // Lo pierde el de fuera (estado = 3)
                                            tanteo1 = 10;
                                            actualizarTorneoUsuario(partido.getId(), 0, 3, new Date(), tanteo1, tanteo2);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            if (hayExpulsion) {
                setMensajeAlerta(getText("alertas.torneos_de_usuario.administrar.expulsion_realizada"));
                obtenerParticipes();
            }

        } catch (Exception e) {
            log.error("Error:",e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }
    

    public String enviarMensaje() {
        recibirMensaje();
        return SUCCESS;
    }

    private void recibirMensaje() {
        //log.debug("recibiendo mensaje " + mensajeTorneo);

        if (mensajeTorneo!=null) {
            try {
                MensajeUsuario mu = new MensajeUsuario();

                Usuario ul = getUsuarioLogado();
                if (ul!=null) {
                    mu.setSender(ul.getId());
                    mu.setFrom(ul.getNickMostrar());
                    mu.setFromUrl(ul.getNick());
                    mu.setReceiver(temporada.getId());
                    mu.setAsunto("");
                    mu.setTexto(mensajeTorneo);

                    mu.setTipoUsuarioEmisor(mu.TIPO_USUARIO_NORMAL);
                    mu.setTipoDestinatario(1);

                    escribirMensajeTorneo(mu);

                    // Refrescar la lista de mensajes
                    setListaMensajesTorneo(leerMensajesTorneo(temporada.getId()));
                }

            } catch (Exception e) {
                log.error("[contactar]: " , e);
            }
        }

    }

    public String mensajes() {
        obtenerTorneo();
        recibirMensaje();
        return TORNEO_MENSAJES;
    }

    public String abandonar() {
        log.debug("abandonar torneo");
        String retorno = SUCCESS;

        // Comprobar si hay expulsiones

        obtenerTorneo();
        obtenerParticipes();

        abandonarTorneo();

        return retorno;
    }

    public String expulsar() {
        log.debug("expulsar torneo");

        consultar();

        if (getUsuarioLogado()!=null && getUsuarioLogado().getId().equals(torneo.getUsuario().getId())) {
            if (elegir_equipo!=null) {
                expulsarTorneo();
            }
        }

        return SUCCESS;
    }

    public String calendario() {
        String retorno = TORNEO_CALENDARIO;

        obtenerTorneo();
        obtenerCalendario();

        return retorno;
    }

    public String resultados() {
        String retorno = TORNEO_RESULTADOS;

        obtenerTorneo();
        obtenerCalendario();

        return retorno;
    }

    public String equipos() {
        String retorno = TORNEO_EQUIPOS;

        // Comprobar si hay expulsiones

        obtenerTorneo();
        obtenerParticipes();

        return retorno;
    }


    public String estadisticas() {
        String retorno = TORNEO_ESTADISTICAS;

        obtenerTorneo();

        calcularAnotacionTorneo();
        calcularAsistenciasTorneo();
        calcularRebotesTorneo();
        calcularRecuperacionesTorneo();
        calcularTaponesTorneo();
        calcularValoracionTorneo();

        return retorno;
    }


    public String clasificacion() {
        String retorno = TORNEO_CLASIFICACION;

        obtenerTorneo();
        obtenerClasificacion(false);

        return retorno;
    }


    public String previa() {
      String retorno = SUCCESS;

      EntityManager em = null;

      try {

        em = emfBasket.createEntityManager(); // checked

            // Si hay "accion"

            if (accion.equals("aceptar")) {
                // Si llegan valores en elegir_equipo, cambiarlos de estado antes de consultar el resto
                if (elegir_equipo != null) {
                    String admitidos = "";
                    List<Equipo> equiposAdmitidos = new ArrayList<Equipo>();
                    for (String idEquipo : elegir_equipo) {                        
                        Equipo aux = em.find(Equipo.class, Integer.parseInt(idEquipo));

                        // Ver si el usuario ya está apuntado

                        // Comprobar que el usuario del equipo no es partícipe del torneo

                        /*
                        Query q = em.createNamedQuery("Participe.findByUsuarioIdTemporadaId");
                        log.debug("idUsurio: " + aux.getUsuario().getId());
                        log.debug("itEmporada: " + temporada.getId());
                        q.setParameter("idUsuario", aux.getUsuario().getId());
                        q.setParameter("idTemporada", temporada.getId());
                        List<Participe> yaEstaParticipando = (List<Participe>)q.getResultList();

                        log.debug("yaEstaParticipando: " + yaEstaParticipando);

                        boolean puedeApuntarse = true;

                        if (yaEstaParticipando.size()>0) {
                            puedeApuntarse = false;
                        }
                         *
                         */

                        boolean puedeApuntarse = true;
                        log.debug("puedeApuntarse: " + puedeApuntarse);

                        if (puedeApuntarse) {
                            admitidos += "," + idEquipo;
                            equiposAdmitidos.add(aux);
                        }
                    }
                    admitidos = admitidos.substring(1);

                    int usuarioTorneo = torneo.getUsuario().getId();
                    int usuarioLogado = getUsuarioLogado().getId();

                    if (usuarioTorneo == usuarioLogado) {
                        Query qa = em.createNativeQuery("update participe set estado = 1 where temporada_id = " + temporada.getId() + " and equipo_id in (" + admitidos + ")");
                        em.getTransaction().begin();
                        qa.executeUpdate();
                        em.getTransaction().commit();

                    }

                    // Mandar el mensaje de aceptado a los equipos aceptados
                    for (Equipo e : equiposAdmitidos) {
                        MensajeUsuario mens = new MensajeUsuario();
                        mens.setFrom("BasketDudes");
                        mens.setSender(0);
                        mens.setTo(torneo.getUsuario().getNickMostrar());
                        mens.setReceiver(e.getUsuario().getId());
                        mens.setTipoDestinatario(MensajeUsuario.TIPO_USUARIO_NORMAL);
                        mens.setTipoUsuarioEmisor(MensajeUsuario.TIPO_USUARIO_ADMINISTRADOR_WEB);

                        mens.setAsunto(getText("mensaje_interno.torneos_de_usuario.aceptado.titulo."+torneo.getUsuario().getIdioma().toLowerCase()));
                        List<Object> params = new ArrayList<Object>();
                        params.add(e.getNombreCompleto());
                        params.add(torneo.getNombre());
                        params.add(torneo.getNombreUrl());
                        mens.setTexto(getText("mensaje_interno.torneos_de_usuario.aceptado.mensaje."+torneo.getUsuario().getIdioma().toLowerCase(),params));

                        escribirMensaje(mens);
                    }
                }
            }

            if (accion.equals("rechazar")) {
                // Si llegan valores en elegir_equipo, cambiarlos de estado antes de consultar el resto
                if (elegir_equipo != null) {
                    String admitidos = "";

                    List<Equipo> equiposRechazados = new ArrayList<Equipo>();

                    for (String idEquipo : elegir_equipo) {
                        admitidos += "," + idEquipo;
                        Equipo aux = em.find(Equipo.class, Integer.parseInt(idEquipo));
                        equiposRechazados.add(aux);
                    }
                    admitidos = admitidos.substring(1);

                    int usuarioTorneo = torneo.getUsuario().getId();
                    int usuarioLogado = getUsuarioLogado().getId();

                    if (usuarioTorneo == usuarioLogado) {
                        Query qa = em.createNativeQuery("delete from participe where temporada_id = " + temporada.getId() + " and equipo_id in (" + admitidos + ")");
                        em.getTransaction().begin();
                        qa.executeUpdate();
                        em.getTransaction().commit();
                    }

                    // Mandar el mensaje de rechazado a los equipos rechazados
                    for (Equipo e : equiposRechazados) {
                        MensajeUsuario mens = new MensajeUsuario();
                        mens.setFrom("BasketDudes");
                        mens.setSender(0);
                        mens.setTo(torneo.getUsuario().getNickMostrar());
                        mens.setReceiver(e.getUsuario().getId());
                        mens.setTipoDestinatario(MensajeUsuario.TIPO_USUARIO_NORMAL);
                        mens.setTipoUsuarioEmisor(MensajeUsuario.TIPO_USUARIO_ADMINISTRADOR_WEB);

                        mens.setAsunto(getText("mensaje_interno.torneos_de_usuario.no_admitido.titulo."+torneo.getUsuario().getIdioma().toLowerCase()));
                        List<Object> params = new ArrayList<Object>();
                        params.add(torneo.getNombre());
                        params.add(torneo.getNombreUrl());
                        params.add(e.getNombreCompleto());
                        mens.setTexto(getText("mensaje_interno.torneos_de_usuario.no_admitido.mensaje."+torneo.getUsuario().getIdioma().toLowerCase(),params));
                        
                        escribirMensaje(mens);
                    }
                }
            }

            mandarInvitaciones(true);

            Query q = em.createNamedQuery("Participe.findByTemporadaIdEstado");
            q.setParameter("temporadaId", temporada.getId());
            q.setParameter("estado", (short)0); // Petición

            int totalRegistros = q.getResultList().size();
            int totalPaginas = (totalRegistros-1)/LISTADO_INSCRITOS_ELEMENTOS_POR_PAGINA + 1;

            cabecera = new InfoCabeceraXHR();
            cabecera.setCorrecto(1);
            cabecera.setActual(pagina);
            cabecera.setTotal(totalPaginas);

            int p1=0, p2=0;

            if (pagina <= (LISTADO_INSCRITOS_HUECOS_LADO_PAGINA+1)) {
                p1 = 1;
                p2 = LISTADO_INSCRITOS_HUECOS_LADO_PAGINA*2 + 1;
            } else if (pagina >= (totalPaginas-LISTADO_INSCRITOS_HUECOS_LADO_PAGINA)) {
                p1 = totalPaginas - (LISTADO_INSCRITOS_HUECOS_LADO_PAGINA*2);
                p2 = totalPaginas;
            } else {
                p1 = pagina - LISTADO_INSCRITOS_HUECOS_LADO_PAGINA;
                p2 = pagina + LISTADO_INSCRITOS_HUECOS_LADO_PAGINA;
            }
            if (p1 < 1) {
                p1 = 1;
            }
            if (p2 > totalPaginas) {
                p2 = totalPaginas;
            }
            cabecera.setPrimeraPagina(p1);
            cabecera.setUltimaPagina(p2);

            q.setMaxResults(LISTADO_INSCRITOS_ELEMENTOS_POR_PAGINA);

            setDatos((List<Participe>)q.getResultList());

            cabecera.setActual(pagina);

            q = em.createNamedQuery("Participe.findByTemporadaIdEstado");
            q.setParameter("temporadaId", temporada.getId());
            q.setParameter("estado", (short)1); // Admitidos
            setListaAdmitidos((List<Participe>)q.getResultList());

        } catch (NoResultException nre) {
            log.debug("No se ha encontrado el torneo 5 " + urlTorneo);
            retorno = NOT_FOUND;
        } catch (Exception e) {
            log.error("", e);
            retorno = ERROR;
            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            try { if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }; } catch (Exception e) { }
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

    public Participe estaEnListaDeEspera(int idUsuario) {

        Participe retorno = null;
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Participe.findByUsuarioIdTemporadaIdEstado");
            q.setParameter("idTemporada", temporada.getId());
            q.setParameter("idUsuario", idUsuario);
            q.setParameter("estado", (short)0); // en lista de espera
            retorno = (Participe)q.getSingleResult();
        } catch (NoResultException nre) {
            log.debug("No se encuentra en lista de espera! " + temporada.getId() + "," + idUsuario);
        } catch (Exception e) {
            log.error("", e);
            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

    public String lista() {
        String retorno = SUCCESS;


        return retorno;
    }

    public String iniciar() {
        //log.debug("torneoUsuario iniciar()");
        String retorno = SUCCESS;

        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked
            
            Query q = em.createNamedQuery("Torneo.findByNombreUrl");
            if (urlTorneo.charAt(urlTorneo.length()-1)=='/') {
                urlTorneo = urlTorneo.substring(0,urlTorneo.length()-1);
            }
            q.setParameter("nombreUrl", urlTorneo);
            Torneo torneo = (Torneo)q.getSingleResult();

            q = em.createNamedQuery("Temporada.findTemporadaActivaByTorneoId");
            q.setParameter("id", torneo.getId());
            q.setMaxResults(1);
            Temporada temporada = (Temporada)q.getSingleResult();

            setTorneo(torneo);
            setTemporada(temporada);

            int idUsuarioLogado = getUsuarioLogado().getId();
            int idUsuarioTorneo = torneo.getUsuario().getId();
            
            if (idUsuarioLogado==idUsuarioTorneo) {

                //log.debug("El usuario logado es el gestor del torneo ... bien");

                DateFormat df = new SimpleDateFormat("dd/MM/yyyy");
                Date fecha = df.parse(fecha_inicio);

                q = em.createNamedQuery("Participe.findByTemporadaIdEstado");
                q.setParameter("temporadaId", temporada.getId());
                q.setParameter("estado", (short)1); // Admitidos
                setListaAdmitidos((List<Participe>)q.getResultList());

                // Crear el calendario, si hay los mismos participes que los que debería haber (bug que permite crear torneos de 3 usuarios)

                if (getListaAdmitidos().size()==temporada.getMaxEquipos()) {

                    Participe[] equiposCalendario = null;
                    //log.debug("getListaAdmitidos().size(): " + getListaAdmitidos().size());
                    if (getListaAdmitidos().size()%2==0) { // Pares
                        equiposCalendario = getListaAdmitidos().toArray(new Participe[]{});
                        //log.debug("1 size equiposCalendario: " + equiposCalendario.length);
                    } else {
                        equiposCalendario = getListaAdmitidos().toArray(new Participe[getListaAdmitidos().size()+1]);
                        //log.debug("2 size equiposCalendario: " + equiposCalendario.length);
                    }

                    // Si hubiera impares, meter uno más para cuadrar el array

                    /*
                    int[] cal1 = {1,2,3,4,5,6,7,8,9,10};
                    int[] cal2 = {11,12,13,14,15,16,17,18,19,20};
                     *
                     */

                    /*
                    int[] cal1 = {1,2,3};
                    int[] cal2 = {4,5,6};
                     *
                     */

                    /*
                        Calculamos la mitad de los participantes, para ver si son
                        pares o no y cuántas jornadas se juegan
                     *
                     */
                    int numEquipos = equiposCalendario.length/2;
                    if (getListaAdmitidos().size()%2==1) { // Impares
                        Participe eDescansa = new Participe();
                        eDescansa.setEquipo(new Equipo());
                        eDescansa.getEquipo().setId(0);
                        equiposCalendario[equiposCalendario.length-1] = eDescansa;
                    }
                    //log.debug("numEquipos: " + numEquipos);

                    int[] cal1 = new int[numEquipos];
                    int[] cal2 = new int[numEquipos];

                    for (int x=0; x<numEquipos; x++) {
                        cal1[x] = equiposCalendario[x].getEquipo().getId();
                        cal2[x] = equiposCalendario[x+numEquipos].getEquipo().getId();
                    }

                    int longCal = cal1.length;

                    int numJornadas = ((cal1.length*2)-1)*2;
                    //log.debug("numJornadas: " + numJornadas);

                    setFrecuencia(temporada.getFrecuencia());

                    GregorianCalendar gc = new GregorianCalendar();
                    GregorianCalendar gcF = new GregorianCalendar();

                    gc.setTime(fecha);
                    gc.set(GregorianCalendar.HOUR_OF_DAY, 0);
                    gc.set(GregorianCalendar.MINUTE, 0);
                    gc.set(GregorianCalendar.SECOND, 0);

                    temporada.setFInicio(gc.getTime());

                    int nJor = 0;
                    //log.debug("nJor: " + nJor);

                    // Grabar los partidos

                    //log.debug("antes del for ...");
                    for (int x=0; x<numJornadas; x++) {
                        //log.debug("x: " + x);
                        nJor = x+1;

                        gcF.setTime(gc.getTime());
                        gcF.add(GregorianCalendar.DATE, frecuencia-1);
                        gcF.set(GregorianCalendar.HOUR_OF_DAY, 23);
                        gcF.set(GregorianCalendar.MINUTE, 59);
                        gcF.set(GregorianCalendar.SECOND, 59);

                        Jornada jornada = new Jornada();
                        //jornada.setTemporadaId(temporada.getId());
                        jornada.setTemporada(temporada);
                        jornada.setNumero((short)nJor);
                        jornada.setFIni(gc.getTime());
                        jornada.setFFin(gcF.getTime());
                        jornada.setEstado((short)0);

                        //log.debug(">>> grabando jornada " + jornada.getNumero());

                        em.getTransaction().begin();
                        em.persist(jornada);
                        em.getTransaction().commit();

                        for (int j=0; j<longCal; j++) {
                            int casa = cal1[j];
                            int fuera = cal2[j];

                            if (x%2==1) {
                                casa = cal2[j];
                                fuera = cal1[j];
                            }

                            CalendarioPK calpk = new CalendarioPK();

                            Equipo equipoCasa = em.find(Equipo.class, casa);
                            Equipo equipoFuera = em.find(Equipo.class, fuera);

                            calpk.setEquipo1(equipoCasa);
                            calpk.setEquipo2(equipoFuera);
                            calpk.setJornadaId(jornada.getId());
                            calpk.setTemporadaId(temporada.getId());


                            Calendario cal = new Calendario();
                            //cal.setCalendarioPK(calpk);
                            cal.setEquipo1(equipoCasa);
                            cal.setEquipo2(equipoFuera);
                            cal.setTemporada(temporada);
                            //cal.setFPartido(gc.getTime());
                            cal.setFIni(gc.getTime());
                            cal.setFFin(gcF.getTime());
                            cal.setJornada(jornada);

                            if (equipoCasa!=null && equipoFuera!=null) {
                                em.getTransaction().begin();
                                em.persist(cal);
                                em.getTransaction().commit();
                            }

                        }

                        // Movimiento de arrays

                        int aux = cal1[longCal-1];

                        for(int k=longCal-1; k>1; k--) {
                            cal1[k] = cal1[k-1];
                        }

                        cal1[1] = cal2[0];

                        for (int k=0; k<longCal-1; k++) {
                            cal2[k] = cal2[k+1];
                        }

                        cal2[longCal-1] = aux;

                        // Mover la fecha a fecha + frecuencia
                        gc.add(GregorianCalendar.DATE, frecuencia);
                    }

                    // Actualizar el torneo con la fecha final, la fecha final de la temporada

                    temporada.setFFin(gcF.getTime());
                    temporada.setfFinPrevista(gcF.getTime());

                    // Empezar temporada

                    temporada.setEstado((short)2); // iniciada
                    em.getTransaction().begin();
                    em.persist(temporada);
                    em.getTransaction().commit();

                    // borrar los participes que estén con estado distinto de 1

                    String sql = "delete from basket.participe where temporada_id = :idTemporada and estado <> 1";
                    em.getTransaction().begin();
                    q = em.createNativeQuery(sql);
                    q.setParameter("idTemporada", temporada.getId());
                    q.executeUpdate();
                    em.getTransaction().commit();

                    // Mandar mensajes interno con el inicio de la competicion

                    for(Participe p:listaAdmitidos) {
                        MensajeUsuario mens = new MensajeUsuario();
                        mens.setFrom("BasketDudes");
                        mens.setSender(0);
                        mens.setTo(torneo.getUsuario().getNickMostrar());
                        mens.setReceiver(p.getEquipo().getUsuario().getId());
                        mens.setTipoDestinatario(MensajeUsuario.TIPO_USUARIO_NORMAL);
                        mens.setTipoUsuarioEmisor(MensajeUsuario.TIPO_USUARIO_ADMINISTRADOR_WEB);

                        mens.setAsunto(getText("mensaje_interno.torneos_de_usuario.iniciado.titulo."+torneo.getUsuario().getIdioma().toLowerCase()));
                        List<Object> params = new ArrayList<Object>();
                        params.add(torneo.getNombre());
                        params.add(torneo.getNombreUrl());
                        params.add(torneo.getUsuario().getNickMostrar());
                        mens.setTexto(getText("mensaje_interno.torneos_de_usuario.iniciado.mensaje."+torneo.getUsuario().getIdioma().toLowerCase(),params));

                        escribirMensaje(mens);
                    }

                    setMensajeAlerta(getText("alertas.torneos_de_usuario.crear.iniciado"));
                }
                retorno = TORNEO_INICIADO;
            } else {
                retorno = ERROR;
            }
        } catch (NoResultException nre) {
            retorno = NOT_FOUND;
        } catch (Exception e) {
            log.error("", e);
            retorno = ERROR;

            if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }
        } finally {
            retorno = consultar();
            try { if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }; } catch (Exception e) { }
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }



    public void obtenerParticipes() {

        log.debug("lunex: obtener participes");

        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Torneo.findByNombreUrl");
            if (urlTorneo.charAt(urlTorneo.length()-1)=='/') {
                urlTorneo = urlTorneo.substring(0,urlTorneo.length()-1);
            }
            q.setParameter("nombreUrl", urlTorneo);
            Torneo torneo = (Torneo)q.getSingleResult();

            log.debug("lunex, torneo de " +urlTorneo + " -> " + torneo);

            q = em.createNamedQuery("Temporada.findTemporadaActivaByTorneoId");
            q.setParameter("id", torneo.getId());
            q.setMaxResults(1);
            Temporada temporada = (Temporada)q.getSingleResult();

            log.debug("lunex: temporada = " + temporada);

            setTorneo(torneo);
            setTemporada(temporada);

            q = em.createNamedQuery("Participe.findByTemporadaIdActivosOExpulsados");
            q.setParameter("temporadaId", temporada.getId());
            log.debug("buscando temporadaId: " + temporada.getId());
            setListaAdmitidos((List<Participe>)q.getResultList());
        } catch (NoResultException nre) {
        } catch (Exception e) {
            log.error("", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }












    public String getNombre_torneo() {
        return nombre_torneo;
    }

    public void setNombre_torneo(String nombre_torneo) {
        this.nombre_torneo = nombre_torneo;
    }

    public String getTipo_torneo() {
        return tipo_torneo;
    }

    public void setTipo_torneo(String tipo_torneo) {
        this.tipo_torneo = tipo_torneo;
    }

    public String getContrasenya_torneo() {
        return contrasenya_torneo;
    }

    public void setContrasenya_torneo(String contrasenya_torneo) {
        this.contrasenya_torneo = contrasenya_torneo;
    }

    public short getNumero_participantes() {
        return numero_participantes;
    }

    public void setNumero_participantes(short numero_participantes) {
        this.numero_participantes = numero_participantes;
    }

    public short getNumero_entre() {
        return numero_entre;
    }

    public void setNumero_entre(short numero_entre) {
        this.numero_entre = numero_entre;
    }

    public short getNumero_y() {
        return numero_y;
    }

    public void setNumero_y(short numero_y) {
        this.numero_y = numero_y;
    }

    public int getFrecuencia() {
        return frecuencia;
    }

    public void setFrecuencia(int frecuencia) {
        this.frecuencia = frecuencia;
    }

    public int getEquipo_inscrito() {
        return equipo_inscrito;
    }

    public void setEquipo_inscrito(int equipo_inscrito) {
        this.equipo_inscrito = equipo_inscrito;
    }

    public String getInvitaciones() {
        return invitaciones;
    }

    public void setInvitaciones(String invitaciones) {
        this.invitaciones = invitaciones;
    }

    public String getUrlRedirect() {
        return urlRedirect;
    }

    public void setUrlRedirect(String url) {
        log.debug("en setUrlRedirect ... " + url);
        this.urlRedirect = url;
    }

    public List<Participe> getListaAdmitidos() {
        return listaAdmitidos;
    }

    public void setListaAdmitidos(List<Participe> listaAdmitidos) {
        this.listaAdmitidos = listaAdmitidos;
    }

    public String getUrlTorneo() {
        return urlTorneo;
    }

    public void setUrlTorneo(String urlTorneo) {
        this.urlTorneo = urlTorneo;
    }

    public Temporada getTemporada() {
        return temporada;
    }

    public void setTemporada(Temporada temporada) {
        this.temporada = temporada;
    }

    public Torneo getTorneo() {
        return torneo;
    }

    public void setTorneo(Torneo torneo) {
        this.torneo = torneo;
    }

    public List<Participe> getDatos() {
        return datos;
    }

    public void setDatos(List<Participe> datos) {
        this.datos = datos;
    }

    public InfoCabeceraXHR getCabecera() {
        return cabecera;
    }

    public void setCabecera(InfoCabeceraXHR cabecera) {
        this.cabecera = cabecera;
    }

    public int getPagina() {
        return pagina;
    }

    public void setPagina(int pagina) {
        this.pagina = pagina;
    }

    public int getCuantos() {
        return cuantos;
    }

    public void setCuantos(int cuantos) {
        this.cuantos = cuantos;
    }

    public String[] getElegir_equipo() {
        return elegir_equipo;
    }

    public void setElegir_equipo(String[] elegir_equipo) {
        this.elegir_equipo = elegir_equipo;
    }

    public String getAccion() {
        return accion;
    }

    public void setAccion(String accion) {
        this.accion = accion;
    }

    public String getFecha_inicio() {
        return fecha_inicio;
    }

    public void setFecha_inicio(String fecha_inicio) {
        this.fecha_inicio = fecha_inicio;
    }

    public List<DatosCalendarioTorneo> getPartidosCalendario() {
        return partidosCalendario;
    }

    // Para el calendario del "scroll"
    public List<DatosCalendario> getCalendario() {
        return calendario;
    }

    public void setCalendario(List<DatosCalendario> calendario) {
        this.calendario = calendario;
    }

    public void setPartidosCalendario(List<DatosCalendarioTorneo> partidosCalendario) {
        this.partidosCalendario = partidosCalendario;
    }

    public String getDescripcion() {
        return descripcion;
    }

    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }

    public List<Participe> getClasificacion() {
        return clasificacion;
    }

    public void setClasificacion(List<Participe> clasificacion) {
        this.clasificacion = clasificacion;
    }

    public List<DatosCalendarioTorneo> getPartidosPendientes() {
        return partidosPendientes;
    }

    public void setPartidosPendientes(List<DatosCalendarioTorneo> partidosPendientes) {
        this.partidosPendientes = partidosPendientes;
    }

    public List<MensajeUsuario> getListaMensajesTorneo() {
        return listaMensajesTorneo;
    }

    public void setListaMensajesTorneo(List<MensajeUsuario> listaMensajesTorneo) {
        this.listaMensajesTorneo = listaMensajesTorneo;
    }

    public List<MensajeUsuario> getListaMensajesTorneoHome() {
        //log.debug("en la home !!!!!!!!!!!!!!: " + listaMensajesTorneo);
        List<MensajeUsuario> retorno = null;
        //log.debug(".... " + listaMensajesTorneo.size());
        if (listaMensajesTorneo.size()<=3) {
            //log.debug("> 1");
            retorno = listaMensajesTorneo;
            //log.debug("retorno 1: " + retorno);
        } else {
            //log.debug("> 2");
            try {
                retorno = new ArrayList<MensajeUsuario>(3);
                retorno.add(listaMensajesTorneo.get(0));
                retorno.add(listaMensajesTorneo.get(1));
                retorno.add(listaMensajesTorneo.get(2));
                //log.debug("retorno 2: " + retorno);
            } catch (Exception e) {
                log.error("Error, " + e);
            }
        }

        return retorno;
    }

    public String getMensajeTorneo() {
        return mensajeTorneo;
    }

    public void setMensajeTorneo(String mensajeTorneo) {
        this.mensajeTorneo = mensajeTorneo;
    }


    // Devolver el objeto Participe de la liga
    public Participe dameParticipe(int idUsuario) {

        Participe retorno = null;

        try {

            obtenerParticipes();

            for(Participe p:listaAdmitidos) {
                if (p.getEquipo().getUsuario().getId().equals(idUsuario)) {
                    retorno = p;
                }
            }

        } catch (Exception e) {
            log.error("Error en dameParticipe: ", e);
        }

        return retorno;
    }

    // Es participante de la liga
    public boolean esParticipe(int idUsuario) {
        boolean retorno = false;

        //log.debug("esParticipe(" + idUsuario + ")");
        try {

            if (torneo.getUsuario().getId().equals(idUsuario)) {
                retorno = true;
            } else {
                obtenerParticipes();

                for(Participe p:listaAdmitidos) {
                    if (p.getEquipo().getUsuario().getId().equals(idUsuario)) {
                        retorno = true;
                    }
                }
            }

            //log.debug("retorno: " + retorno);

        } catch (Exception e) {
            log.error("Error en esParticipe: ", e);
        }
        return retorno;

    }



    // Estadísticas





    private void calcularValoracionTorneo() {
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager();

            /*
             * Consulta

             select ejp.jugador_id
             from basket.partido p, basket.jornada j,
                basket.temporada t, basket.est_jugador_partido ejp
             where t.id = j.temporada_id
                and p.jornada_id = j.id
                and ejp.partido_id = p.id
                and t.id = 53
             group by ejp.jugador_id
             order by sum(ejp.valoracion) desc;

             */

            Query q = em.createNativeQuery("select ejp.jugador_id as idJugador, sum(ejp.valoracion) as totalValor, count(*) as numPartidos from basket.partido p, basket.jornada j, basket.temporada t, basket.est_jugador_partido ejp where t.id = j.temporada_id and p.jornada_id = j.id and ejp.partido_id = p.id and t.id = :idTemporada group by ejp.jugador_id order by sum(ejp.valoracion)/count(*) desc", DatosEstadisticaTorneo.class);
            //log.debug(">>>>> estadisticas valoracion torneo: " + temporada.getId());
            q.setParameter("idTemporada", temporada.getId());
            q.setMaxResults(3);

            //List<Jugador> lista = new ArrayList<Jugador>();

            estValoracionTorneo = new ArrayList<DatosEstadisticaTorneo>();
            List results = q.getResultList();
            if (results.size()!=0) {
                Iterator iterator = results.iterator();
                while (iterator.hasNext()) {
                    DatosEstadisticaTorneo det = (DatosEstadisticaTorneo)iterator.next();
                    log.debug(">>> buscando en estTorneo: " + det.getIdJugador());
                    JugadorBasico j = em.find(JugadorBasico.class, det.getIdJugador());

                    det.setNombreJugador(j.getMJugador().getNombre());                    
                    det.setUrlJugador(j.getMJugador().getNombreUrl());
                    
                    if (j.getEquipo() != null) {
                        Equipo e = j.getEquipo();

                        det.setNombreEquipo(e.getNombreCompleto());
                        det.setUrlEquipo(e.getNombreUrl());
                        det.setLogoimgId(e.getAspecto().getLogoimgId());
                    }

                    estValoracionTorneo.add(det);
                }
            }

        } catch (Exception e) {
            log.error("Estadisticas: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }

    private void calcularAnotacionTorneo() {
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager();

            Query q = em.createNativeQuery("select ejp.jugador_id as idJugador, sum(ejp.puntos) as totalValor, count(*) as numPartidos from basket.partido p, basket.jornada j, basket.temporada t, basket.est_jugador_partido ejp where t.id = j.temporada_id and p.jornada_id = j.id and ejp.partido_id = p.id and t.id = :idTemporada group by ejp.jugador_id order by sum(ejp.puntos)/count(*) desc", DatosEstadisticaTorneo.class);
            //log.debug(">>>>> estadisticas valoracion torneo: " + temporada.getId());
            q.setParameter("idTemporada", temporada.getId());
            q.setMaxResults(3);

            //List<Jugador> lista = new ArrayList<Jugador>();

            estAnotacionTorneo = new ArrayList<DatosEstadisticaTorneo>();
            List results = q.getResultList();
            if (results.size()!=0) {
                Iterator iterator = results.iterator();
                while (iterator.hasNext()) {
                    DatosEstadisticaTorneo det = (DatosEstadisticaTorneo)iterator.next();
                    log.debug(">>> buscando en estTorneo: " + det.getIdJugador());
                    JugadorBasico j = em.find(JugadorBasico.class, det.getIdJugador());

                    det.setNombreJugador(j.getMJugador().getNombre());
                    det.setUrlJugador(j.getMJugador().getNombreUrl());

                    if (j.getEquipo() != null) {
                        Equipo e = j.getEquipo();

                        det.setNombreEquipo(e.getNombreCompleto());
                        det.setUrlEquipo(e.getNombreUrl());
                        det.setLogoimgId(e.getAspecto().getLogoimgId());
                    }

                    estAnotacionTorneo.add(det);
                }
            }

        } catch (Exception e) {
            log.error("Estadisticas: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }

    private void calcularRebotesTorneo() {
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager();

            Query q = em.createNativeQuery("select ejp.jugador_id as idJugador, sum(ejp.rebotes_ataque+ejp.rebotes_defensa) as totalValor, count(*) as numPartidos from basket.partido p, basket.jornada j, basket.temporada t, basket.est_jugador_partido ejp where t.id = j.temporada_id and p.jornada_id = j.id and ejp.partido_id = p.id and t.id = :idTemporada group by ejp.jugador_id order by sum(ejp.rebotes_ataque+ejp.rebotes_defensa)/count(*) desc", DatosEstadisticaTorneo.class);
            //log.debug(">>>>> estadisticas valoracion torneo: " + temporada.getId());
            q.setParameter("idTemporada", temporada.getId());
            q.setMaxResults(3);

            //List<Jugador> lista = new ArrayList<Jugador>();

            estRebotesTorneo = new ArrayList<DatosEstadisticaTorneo>();
            List results = q.getResultList();
            if (results.size()!=0) {
                Iterator iterator = results.iterator();
                while (iterator.hasNext()) {
                    DatosEstadisticaTorneo det = (DatosEstadisticaTorneo)iterator.next();
                    log.debug(">>> buscando en estTorneo: " + det.getIdJugador());
                    JugadorBasico j = em.find(JugadorBasico.class, det.getIdJugador());

                    det.setNombreJugador(j.getMJugador().getNombre());
                    det.setUrlJugador(j.getMJugador().getNombreUrl());

                    if (j.getEquipo() != null) {
                        Equipo e = j.getEquipo();

                        det.setNombreEquipo(e.getNombreCompleto());
                        det.setUrlEquipo(e.getNombreUrl());
                        det.setLogoimgId(e.getAspecto().getLogoimgId());
                    }

                    estRebotesTorneo.add(det);
                }
            }

        } catch (Exception e) {
            log.error("Estadisticas: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }

    private void calcularAsistenciasTorneo() {
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager();

            Query q = em.createNativeQuery("select ejp.jugador_id as idJugador, sum(ejp.asistencias) as totalValor, count(*) as numPartidos from basket.partido p, basket.jornada j, basket.temporada t, basket.est_jugador_partido ejp where t.id = j.temporada_id and p.jornada_id = j.id and ejp.partido_id = p.id and t.id = :idTemporada group by ejp.jugador_id order by sum(ejp.asistencias)/count(*) desc", DatosEstadisticaTorneo.class);
            //log.debug(">>>>> estadisticas valoracion torneo: " + temporada.getId());
            q.setParameter("idTemporada", temporada.getId());
            q.setMaxResults(3);

            //List<Jugador> lista = new ArrayList<Jugador>();

            estAsistenciasTorneo = new ArrayList<DatosEstadisticaTorneo>();
            List results = q.getResultList();
            if (results.size()!=0) {
                Iterator iterator = results.iterator();
                while (iterator.hasNext()) {
                    DatosEstadisticaTorneo det = (DatosEstadisticaTorneo)iterator.next();
                    log.debug(">>> buscando en estTorneo: " + det.getIdJugador());
                    JugadorBasico j = em.find(JugadorBasico.class, det.getIdJugador());

                    det.setNombreJugador(j.getMJugador().getNombre());
                    det.setUrlJugador(j.getMJugador().getNombreUrl());

                    if (j.getEquipo() != null) {
                        Equipo e = j.getEquipo();

                        det.setNombreEquipo(e.getNombreCompleto());
                        det.setUrlEquipo(e.getNombreUrl());
                        det.setLogoimgId(e.getAspecto().getLogoimgId());
                    }

                    estAsistenciasTorneo.add(det);
                }
            }

        } catch (Exception e) {
            log.error("Estadisticas: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }

    private void calcularTaponesTorneo() {
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager();

            Query q = em.createNativeQuery("select ejp.jugador_id as idJugador, sum(ejp.tapones-ejp.tapones_contra) as totalValor, count(*) as numPartidos from basket.partido p, basket.jornada j, basket.temporada t, basket.est_jugador_partido ejp where t.id = j.temporada_id and p.jornada_id = j.id and ejp.partido_id = p.id and t.id = :idTemporada group by ejp.jugador_id order by sum(ejp.tapones-ejp.tapones_contra)/count(*) desc", DatosEstadisticaTorneo.class);
            //log.debug(">>>>> estadisticas valoracion torneo: " + temporada.getId());
            q.setParameter("idTemporada", temporada.getId());
            q.setMaxResults(3);

            //List<Jugador> lista = new ArrayList<Jugador>();

            estTaponesTorneo = new ArrayList<DatosEstadisticaTorneo>();
            List results = q.getResultList();
            if (results.size()!=0) {
                Iterator iterator = results.iterator();
                while (iterator.hasNext()) {
                    DatosEstadisticaTorneo det = (DatosEstadisticaTorneo)iterator.next();
                    log.debug(">>> buscando en estTorneo: " + det.getIdJugador());
                    JugadorBasico j = em.find(JugadorBasico.class, det.getIdJugador());

                    det.setNombreJugador(j.getMJugador().getNombre());
                    det.setUrlJugador(j.getMJugador().getNombreUrl());

                    if (j.getEquipo() != null) {
                        Equipo e = j.getEquipo();

                        det.setNombreEquipo(e.getNombreCompleto());
                        det.setUrlEquipo(e.getNombreUrl());
                        det.setLogoimgId(e.getAspecto().getLogoimgId());
                    }

                    estTaponesTorneo.add(det);
                }
            }

        } catch (Exception e) {
            log.error("Estadisticas: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }

    private void calcularRecuperacionesTorneo() {
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager();

            Query q = em.createNativeQuery("select ejp.jugador_id as idJugador, sum(ejp.robos-ejp.perdidas) as totalValor, count(*) as numPartidos from basket.partido p, basket.jornada j, basket.temporada t, basket.est_jugador_partido ejp where t.id = j.temporada_id and p.jornada_id = j.id and ejp.partido_id = p.id and t.id = :idTemporada group by ejp.jugador_id order by sum(ejp.robos-ejp.perdidas)/count(*) desc", DatosEstadisticaTorneo.class);
            //log.debug(">>>>> estadisticas valoracion torneo: " + temporada.getId());
            q.setParameter("idTemporada", temporada.getId());
            q.setMaxResults(3);

            //List<Jugador> lista = new ArrayList<Jugador>();

            estRecuperacionesTorneo = new ArrayList<DatosEstadisticaTorneo>();
            List results = q.getResultList();
            if (results.size()!=0) {
                Iterator iterator = results.iterator();
                while (iterator.hasNext()) {
                    DatosEstadisticaTorneo det = (DatosEstadisticaTorneo)iterator.next();
                    log.debug(">>> buscando en estTorneo: " + det.getIdJugador());
                    JugadorBasico j = em.find(JugadorBasico.class, det.getIdJugador());

                    det.setNombreJugador(j.getMJugador().getNombre());
                    det.setUrlJugador(j.getMJugador().getNombreUrl());

                    if (j.getEquipo() != null) {
                        Equipo e = j.getEquipo();

                        det.setNombreEquipo(e.getNombreCompleto());
                        det.setUrlEquipo(e.getNombreUrl());
                        det.setLogoimgId(e.getAspecto().getLogoimgId());
                    }

                    estRecuperacionesTorneo.add(det);
                }
            }

        } catch (Exception e) {
            log.error("Estadisticas: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
    }


    public List<DatosEstadisticaTorneo> getEstValoracionTorneo() {
        return estValoracionTorneo;
    }

    public void setEstValoracionTorneo(List<DatosEstadisticaTorneo> estValoracion) {
        this.estValoracionTorneo = estValoracion;
    }

    public List<DatosEstadisticaTorneo> getEstAnotacionTorneo() {
        return estAnotacionTorneo;
    }

    public void setEstAnotacionTorneo(List<DatosEstadisticaTorneo> estAnotacion) {
        this.estAnotacionTorneo = estAnotacion;
    }

    public List<DatosEstadisticaTorneo> getEstRebotesTorneo() {
        return estRebotesTorneo;
    }

    public void setEstRebotesTorneo(List<DatosEstadisticaTorneo> estRebotes) {
        this.estRebotesTorneo = estRebotes;
    }

    public List<DatosEstadisticaTorneo> getEstAsistenciasTorneo() {
        return estAsistenciasTorneo;
    }

    public void setEstAsistenciasTorneo(List<DatosEstadisticaTorneo> estAsistencias) {
        this.estAsistenciasTorneo = estAsistencias;
    }

    public List<DatosEstadisticaTorneo> getEstTaponesTorneo() {
        return estTaponesTorneo;
    }

    public void setEstTaponesTorneo(List<DatosEstadisticaTorneo> estTapones) {
        this.estTaponesTorneo = estTapones;
    }

    public List<DatosEstadisticaTorneo> getEstRecuperacionesTorneo() {
        return estRecuperacionesTorneo;
    }

    public void setEstRecuperacionesTorneo(List<DatosEstadisticaTorneo> estRecuperaciones) {
        this.estRecuperacionesTorneo = estRecuperaciones;
    }

    public List<DatosCalendarioTorneo> getPartidosPendientesAdministrador() {
        return partidosPendientesAdministrador;
    }

    public void setPartidosPendientesAdministrador(List<DatosCalendarioTorneo> partidosPendientesAdministrador) {
        this.partidosPendientesAdministrador = partidosPendientesAdministrador;
    }

    public String getFecha() {
        return fecha;
    }

    public void setFecha(String fecha) {
        this.fecha = fecha;
    }

    public int getIdPartido() {
        return idPartido;
    }

    public void setIdPartido(int idPartido) {
        this.idPartido = idPartido;
    }

    public int getIdTorneo() {
        return idTorneo;
    }

    public void setIdTorneo(int idTorneo) {
        this.idTorneo = idTorneo;
    }

    public int getResultadoAdministracion() {
        return resultadoAdministracion;
    }

    public void setResultadoAdministracion(int resultadoAdministracion) {
        this.resultadoAdministracion = resultadoAdministracion;
    }

    public String getFecha_aplazamiento() {
        return fecha_aplazamiento;
    }

    public void setFecha_aplazamiento(String fecha_aplazamiento) {
        this.fecha_aplazamiento = fecha_aplazamiento;
    }

    public String getMensaje_administrador() {
        return mensaje_administrador;
    }

    public void setMensaje_administrador(String mensaje_administrador) {
        this.mensaje_administrador = mensaje_administrador;
    }

    public boolean isTemporadaIniciada() {
        return temporadaIniciada;
    }

    public void setTemporadaIniciada(boolean temporadaIniciada) {
        this.temporadaIniciada = temporadaIniciada;
    }

    public boolean isTemporadaFinalizada() {
        return temporadaFinalizada;
    }

    public void setTemporadaFinalizada(boolean temporadaFinalizada) {
        this.temporadaFinalizada = temporadaFinalizada;
    }

    public Jornada getJornadaEnCurso() {
        return jornadaEnCurso;
    }

    public void setJornadaEnCurso(Jornada jornadaEnCurso) {
        this.jornadaEnCurso = jornadaEnCurso;
    }

    public int getJornada() {
        return jornada;
    }

    public void setJornada(int jornada) {
        this.jornada = jornada;
    }

    public List<DatosCalendarioTorneo> getPartidosCalendarioJornada() {
        return partidosCalendarioJornada;
    }

    public void setPartidosCalendarioJornada(List<DatosCalendarioTorneo> partidosCalendarioJornada) {
        this.partidosCalendarioJornada = partidosCalendarioJornada;
    }

    /*
    public List<DatosCalendarioTorneo> getPartidosCalendarioCarrusel() {
        return partidosCalendarioCarrusel;
    }

    public void setPartidosCalendarioCarrusel(List<DatosCalendarioTorneo> partidosCalendarioCarrusel) {
        this.partidosCalendarioCarrusel = partidosCalendarioCarrusel;
    }
     * 
     */

    public int getNumJornadasCarrusel() {
        return numJornadasCarrusel;
    }

    public void setNumJornadasCarrusel(int numJornadasCarrusel) {
        this.numJornadasCarrusel = numJornadasCarrusel;
    }

}


